home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / scbench.arc / MATRIX.C < prev    next >
Text File  |  1980-01-01  |  6KB  |  277 lines
  1. /*
  2. ** BYTE Small-C Matrix Benchmark
  3. ** Version 1 for 8088/8086/80286
  4. ** March, 1988
  5. ** Written in BYTE Small-C
  6. ** Based on Small-C by J.E. Hendrix
  7. **
  8. ** NOTES: 
  9. ** 1) This benchmark constructs only square matrices.
  10. ** 2) Small C only supports 1 dimentional arrays.  The
  11. **    the mathematics required to support 2-dimensional
  12. **    arrays therefore appears at the C-code level.
  13. ** 3) The routine printmat() is provided at the end of the
  14. **    program if you wish to print out the arrays and verify
  15. **    that the matrix operations function properly.
  16. **
  17. ** Operation:
  18. ** 1. Allocate space for 3 square matrices, each
  19. **    MATSIZ x MATSIZ big.
  20. ** 2. Fill the first 2 matrices with random numbers.
  21. ** 3. Turn on the stopwatch
  22. ** 4. Add the first 2 matrices, result in third.
  23. ** 5. Turn off the stopwatch.
  24. ** 6. Add elapsed time to total time.
  25. ** 7. Fill the first 2 matrices with random numbers.
  26. ** 8. Turn on the stopwatch.
  27. ** 9. Multiply the first 2 matrices, result in third.
  28. ** 10. Turn off the stopwatch.
  29. ** 11. Add elapsed time to total time.
  30. ** 12. Turn on the stopwatch.
  31. ** 13. Transpose matrix 1, result in matrix 2.
  32. ** 14. Turn off the stopwatch.
  33. ** 15. Add elapsed time to total time.
  34. ** 16. Report results.
  35. ** 17. Calculate empty loop time.
  36. ** 18. Report results.
  37. ** 19. Free the space claimed by the matrices.
  38. */
  39.  
  40. #include stdio.h
  41.  
  42. #define MATSIZ    60        /* Matrix dimension */
  43. #define BPINT    2        /* Bytes per integer */
  44. #define CEIL    15        /* Largest number allowed */
  45. int *mat1,*mat2,*mat3;        /* Pointers for matrices */
  46. int tblock[4];            /* Timer block */
  47. int ttblock[4];            /* Total time accumulator */
  48. int seed;            /* Seed for random number generator */
  49.  
  50.  
  51. main()
  52. {
  53.     int i;
  54.  
  55.     /* Announce yourself */
  56.     printf("BYTE Small-C Matrix Benchmark\n");
  57.     ttblock[0]=ttbloc[1]=ttblock[2]=ttblock[3]=0;
  58.  
  59.     /* Set up the matrices */
  60.     mat1=calloc(MATSIZ*MATSIZ,BPINT);
  61.     if(mat1==NULL) {
  62.       printf("No space for matrix 1\n");
  63.       exit(0);
  64.     }
  65.  
  66.     mat2=calloc(MATSIZ*MATSIZ,BPINT);
  67.     if(mat2==NULL)     {
  68.       printf("No space for matrix 2\n");
  69.       exit(0);
  70.     }
  71.  
  72.     mat3=calloc(MATSIZ*MATSIZ,BPINT);
  73.     if(mat3==NULL) {
  74.       printf("No space for matrix 3\n");
  75.       exit(0);
  76.     }
  77.  
  78.     /* Now fill up the first two matrices */
  79.     seed=0;
  80.     for(i=0;i<MATSIZ*MATSIZ;++i) {
  81.       mat1[i]=randwc(CEIL);
  82.       mat2[i]=randwc(CEIL);
  83.     }
  84.  
  85.     /* Add the two matrices */
  86.     printf("Adding two matrices...\n");
  87.     gtime(tblock);
  88.     madd(mat1,mat2,mat3,MATSIZ,MATSIZ);
  89.     calctim(tblock);
  90.     acctime();
  91.  
  92.     /* Regenerate the matrices */
  93.     seed=0;
  94.     for(i=0;i<MATSIZ*MATSIZ;++i) {
  95.       mat1[i]=randwc(CEIL);
  96.       mat2[i]=randwc(CEIL);
  97.     }
  98.  
  99.     /* Multiply the two matrices */
  100.     printf("Multiplying two matrices...\n");
  101.     gtime(tblock);
  102.     mmult(mat1,mat2,mat3,MATSIZ,MATSIZ,MATSIZ,MATSIZ);
  103.     calctim(tblock);
  104.     acctime();
  105.  
  106.     /* Transpose matrix 1 into matrix 2 */
  107.     printf("Transpose...\n\n");
  108.     gtime(tblock);
  109.     mtrans(mat1,mat2,MATSIZ,MATSIZ);
  110.     calctim(tblock);
  111.     acctime();
  112.  
  113.     /* Report total time */
  114.     printf("Results:  (HH:MM:SS:1/100ths)\n");
  115.     printf("Time: %d:%d:%d:%d\n",ttblock[0],ttblock[1],
  116.       ttblock[2],ttblock[3]);
  117.     /* Calculate empty loop time */
  118.     gtime(tblock);
  119.     mtlptime(MATSIZ);
  120.     calctim(tblock);
  121.     printf("Empty loop: %d:%d:%d:%d\n\n",tblock[0],tblock[1],
  122.       tblock[2],tblock[3]);
  123.  
  124.     /* Free up the space you claimed */
  125.     free(mat3);
  126.     free(mat2);
  127.     free(mat1);
  128.  
  129.     printf("Press RETURN to exit:");
  130.     fgetc(stdin);
  131.  
  132.     exit(0);
  133. }
  134.  
  135. /*
  136. ** madd(aray1,aray2,aray3,trows,tcols)
  137. ** Adds matrix aray1 to matrix aray2, stores result in aray3.
  138. ** trows and tcols are the total rows and colums of the arrays
  139. */
  140. madd(aray1,aray2,aray3,trows,tcols)
  141. int aray1[],aray2[],aray3[];
  142. int trows,tcols;
  143. {
  144.     int i,j;
  145.  
  146.     for(i=0;i<trows;++i)
  147.       for(j=0;j<tcols;++j)
  148.         aray3[i*tcols+j]=aray1[i*tcols+j]+
  149.           aray2[i*tcols+j];
  150.     return;
  151. }
  152.  
  153. /*
  154. ** mmult(aray1,aray2,aray3,row1,col1,row2,col2)
  155. ** Multiplies aray1 by aray2, stores result in aray3.
  156. ** row1,col1 = dimension of aray1
  157. ** row2,col2 = dimension of aray2
  158. */
  159. mmult(aray1,aray2,aray3,row1,col1,row2,col2)
  160. int aray1[],aray2[],aray3[];
  161. int row1,col1,row2,col2;
  162. {
  163.     int i,j,k;
  164.  
  165.     for(i=0;i<row1;++i)
  166.       for(j=0;j<col2;++j)
  167.       {  aray3[i*col1+j]=0;
  168.          for(k=0;k<col1;++k)
  169.            aray3[i*col1+j]+=aray1[i*col1+k]*
  170.                         aray2[k*col2+j];
  171.       }
  172.       return;
  173. }
  174.  
  175. /*
  176. ** mtrans(aray1,aray2,row,col)
  177. ** Perform the matrix transpose of aray1, store result in aray2.
  178. ** row,col are the dimensions of the matrix (must be square)
  179. */
  180. mtrans(aray1,aray2,row,col)
  181. int aray1[],aray2[];
  182. int row,col;
  183. {
  184.     int i,j;
  185.  
  186.     for(i=0;i<col;++i)
  187.       for(j=0;j<row;++j)
  188.         aray2[i*col+j]=aray1[j*row+i];
  189.     return;
  190. }
  191.  
  192. /*
  193. ** randwc(x)
  194. ** Get a random number (positive) with ceiling x.
  195. */
  196. randwc(x)
  197. int x;
  198. {
  199.  
  200.     if(x==0) return(0);
  201.     seed=rand(seed);    /* Get a random number */
  202.     return(seed%x);
  203. }
  204.  
  205. /*
  206. ** Take the time interval stored in tblock[] and add that to
  207. ** the array holding total accumulated time (ttblock[]).
  208. */
  209. acctime()
  210. {
  211.     ttblock[3]+=tblock[3];    /* Hundredths */
  212.     if(ttblock[3]>=100) {
  213.         ttblock[2]+=1;
  214.         ttblock[3]-=100;
  215.     }
  216.     ttblock[2]+=tblock[2]; /* Seconds */
  217.     if(ttblock[2]>=60) {
  218.         ttblock[1]+=1;
  219.         ttblock[2]-=60;
  220.     }
  221.     ttblock[1]+=tblock[1]; /* Minutes */
  222.     if(ttblock[1]>=60) {
  223.         ttblock[0]+=1;
  224.         ttblock[1]-=60;
  225.     }
  226.     ttblock[0]+=tblock[0];    /* Hours */
  227.     return;
  228. }
  229.  
  230. /*
  231. ** mtlptime(msize)
  232. ** This routine executes a bunch of empty loops that
  233. ** are equivalent to the loops that occur inside the
  234. ** matrix add, multiply, and transpose functions.
  235. ** This function assumes the matrices are square.
  236. */
  237. mtlptime(msize)
  238. int msize;
  239.  
  240. {    int i,j,k;
  241.  
  242.     /* Empty loop for an add */
  243.     for(i=0;i<msize;++i)
  244.       for(j=0;j<msize;++j) ;
  245.  
  246.     /* Empty loop for a multiply */
  247.     for(i=0;i<msize;++i)
  248.       for(j=0;j<msize;++j)
  249.         for(k=0;k<msize;++k) ;
  250.  
  251.     /* Empty loop for a transpose */
  252.     for(i=0;i<msize;++i)
  253.       for(j=0;j<msize;++j) ;
  254.  
  255.     return;
  256. }
  257.  
  258. /*
  259. ** printmat(aray,rows,cols)
  260. ** Print out a matrix
  261. ** This routine was added so you can print out matrices after
  262. ** operations were performed on them to verify that the results
  263. ** are correct.
  264. */
  265. printmat(aray,rows,cols)
  266. int aray[],rows,cols;
  267. {
  268.     int i,j;
  269.  
  270.     for(i=0;i<rows;++i) {
  271.       for(j=0;j<cols;++j)
  272.         printf("%d ",aray[i*cols+j]);
  273.       printf("\n");
  274.     }
  275.     return;
  276. }
  277.